package com.example.coordinartordemo.demo2;

import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.coordinatorlayout.widget.CoordinatorLayout;
import androidx.core.view.ViewCompat;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import java.util.Arrays;

public class SampleHeaderBehavior extends CoordinatorLayout.Behavior<TextView> {
    private static final String TAG = "SampleHeaderBehavior";
    private boolean upReach; // 界面整体向上滑动，达到列表可滑动的临界点
    private boolean downReach;// 列表向上滑动后，再向下滑动，达到界面整体可滑动的临界点
    private int lastPosition = -1;// 列表上一个全部可见的item位置
    public SampleHeaderBehavior() {
        super();
    }

    public SampleHeaderBehavior(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public boolean onInterceptTouchEvent(@NonNull CoordinatorLayout parent, @NonNull TextView child, @NonNull MotionEvent ev) {

        Log.e(TAG,"onInterceptTouchEvent");
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                downReach = false;
                upReach = false;
                break;
        }
        return super.onInterceptTouchEvent(parent, child, ev);
    }

    /**
     * 当coordinatorlayout的子view试图开始嵌套滑动的时候调用。
     * 返回值为true时，表明coordinatorlayout充当nested scroll parent 处理这次滑动。
     * 只有返回值为true时，Behavior才能收到后面的一些nested scroll的事件回调
     * @param coordinatorLayout
     * @param child
     * @param directTargetChild
     * @param target
     * @param axes  嵌套滑动的方向
     * @param type
     * @return
     */
    @Override
    public boolean onStartNestedScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull TextView child, @NonNull View directTargetChild, @NonNull View target, int axes, int type) {

        Log.e(TAG,"onStartNestedScroll:axes"+axes+"  type:"+type);

        return axes == ViewCompat.SCROLL_AXIS_VERTICAL;
    }

    /**
     * 嵌套滑动发生前调用
     * @param coordinatorLayout
     * @param child
     * @param target
     * @param dx
     * @param dy 滑动距离，列表向下滑动为负，列表向上滑动为正了多少距离。
     * @param consumed 修改这个数组表示你消费了多少距离，假设用户滑动了100px,child 做了90px 的位移，你需要把 consumed［1］的值改成90，这样coordinatorLayout就能知道只处理剩下的10px的滚动
     * @param type
     */
    @Override
    public void onNestedPreScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull TextView child, @NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {
        super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
        Log.e(TAG,"onNestedPreScroll:dx:"+dx+" dy:"+dy+" consumed:"+ Arrays.toString(consumed)+" type:"+type);
        if (target instanceof RecyclerView) {
            RecyclerView list = (RecyclerView) target;
            // 列表第一个全部可见Item的位置
            int pos = ((LinearLayoutManager) list.getLayoutManager()).findFirstCompletelyVisibleItemPosition();
            if (pos == 0 && pos < lastPosition) {
                downReach = true;
            }
            // 整体可以滑动，否则RecyclerView消费滑动事件
            if (canScroll(child, dy) && pos == 0) {
                float finalY = child.getTranslationY() - dy;
                if (finalY < -child.getHeight()) {
                    finalY = -child.getHeight();
                    upReach = true;
                } else if (finalY > 0) {
                    finalY = 0;
                }
                child.setTranslationY(finalY);
                // 让CoordinatorLayout消费滑动事件
                consumed[1] = dy;
            }
            lastPosition = pos;
        }
    }

    /**
     * 边界处理
     * @param child
     * @param scrollY
     * @return
     */
    private boolean canScroll(View child, float scrollY) {
        if (scrollY > 0 && child.getTranslationY() == -child.getHeight() && !upReach) {
            return false;
        }

        if (downReach) {
            return false;
        }
        return true;
    }
}
